// ai-chat.js
const BaiduSpeechRecognition = require("../../utils/baidu-speech.js");

Page({
  data: {
    messages: [],
    inputText: '',
    isLoading: false,
    scrollToView: '',
    isStreaming: false,
    streamingText: '',
    streamingIndex: 0,
    streamSpeed: 'normal', // fast, normal, slow
    isRecording: false,
    voiceRecorder: null,
    chatId: null, // 当前对话ID
    chatTitle: '', // 对话标题
    // 百度云语音识别配置
    baiduConfig: {
      apiKey: 'G1biPfgozYJlJr5XXEztrmuv',
      secretKey: 'K9GvJC7AcumJuWMXDqGFp1b1uYUYtcSs',
      appId: '120200305',
      format: 'mp3', // 改为mp3格式，兼容性更好
      sampleRate: 16000,
      maxDuration: 60000
    },
    baiduSpeech: null // 百度语音识别实例
  },

  onLoad: async function (options) {
    console.log('AI对话页面加载', options);
    
    // 初始化百度云语音识别
    this.setData({
      baiduSpeech: new BaiduSpeechRecognition(this.data.baiduConfig)
    });
    
    // 初始化录音器
    this.initRecorderManager();
    
    // 处理对话ID参数
    if (options.chatId) {
      this.setData({
        chatId: options.chatId
      });
      this.loadChatHistory(options.chatId);
    } else {
      // 创建新对话
      this.createNewChat();
      // 只有新对话才添加欢迎消息
      this.addWelcomeMessage();
    }
  },

  onShow: function () {
    console.log('AI对话页面显示');
  },

  onUnload: function() {
    console.log('AI对话页面卸载');
    try {
      // 停止录音
      if (this.data.voiceRecorder) {
        this.data.voiceRecorder.stop();
      }
    } catch (error) {
      console.error('停止录音失败:', error);
    }
  },

  // 初始化录音管理器
  initRecorderManager: function() {
    try {
      console.log('=== 录音管理器初始化开始 ===');
      
      // 检查环境信息
      const systemInfo = wx.getSystemInfoSync();
      console.log('系统信息:', {
        platform: systemInfo.platform,
        version: systemInfo.version,
        SDKVersion: systemInfo.SDKVersion,
        brand: systemInfo.brand,
        model: systemInfo.model
      });
      
      // 检查是否支持录音
      if (!wx.getRecorderManager) {
        console.error('当前环境不支持录音功能');
        wx.showToast({
          title: '当前环境不支持录音',
          icon: 'none',
          duration: 2000
        });
        return;
      }
      
      console.log('开始获取录音管理器...');
      const recorderManager = wx.getRecorderManager();
      
      if (!recorderManager) {
        console.error('获取录音管理器失败');
        wx.showToast({
          title: '录音管理器获取失败',
          icon: 'none',
          duration: 2000
        });
        return;
      }
      
      console.log('录音管理器获取成功:', recorderManager);
      
      // 设置录音事件监听器（只设置一次）
      this.setupRecorderEvents(recorderManager);
      
      this.setData({
        voiceRecorder: recorderManager
      });
      
      console.log('=== 录音管理器初始化完成 ===');
      
    } catch (error) {
      console.error('录音管理器初始化异常:', error);
      wx.showToast({
        title: '录音功能初始化失败: ' + error.message,
        icon: 'none',
        duration: 3000
      });
    }
  },

  // 添加欢迎消息
  addWelcomeMessage: function() {
    const welcomeMessage = {
      type: 'ai',
      content: '你好！我是AI解题助手，有什么学习问题可以随时问我哦~',
      timestamp: Date.now()
    };
    
    this.setData({
      messages: [welcomeMessage]
    });
  },

  // 输入框内容变化
  onInputChange: function(e) {
    this.setData({
      inputText: e.detail.value
    });
  },

  // 发送消息
  sendMessage: function() {
    const inputText = this.data.inputText.trim();
    if (!inputText || this.data.isLoading) {
      return;
    }

    // 添加用户消息
    const userMessage = {
      type: 'user',
      content: inputText,
      timestamp: Date.now()
    };

    // 添加AI加载消息
    const aiLoadingMessage = {
      type: 'ai',
      content: '',
      isLoading: true,
      timestamp: Date.now()
    };

    this.setData({
      messages: [...this.data.messages, userMessage, aiLoadingMessage],
      inputText: '',
      isLoading: true
    });

    // 滚动到底部
    this.scrollToBottom();

    // 保存对话记录
    this.saveChatHistory();

    // 调用AI接口
    this.callAIService(inputText);
  },

  // 调用AI服务
  callAIService: function(question) {
    // 启用真实API调用
    const useRealAPI = true; // 设置为true启用真实API
    
    if (!useRealAPI) {
      // 使用模拟回复
      setTimeout(() => {
        const mockResponse = this.getMockAIResponse(question);
        const messages = this.data.messages.slice(0, -1); // 移除加载消息
        const aiMessage = {
          type: 'ai',
          content: mockResponse,
          isLoading: false,
          timestamp: Date.now()
        };
        
        this.setData({
          messages: [...messages, aiMessage],
          isLoading: false
        });
        
        this.scrollToBottom();
        
        // 保存对话记录
        this.saveChatHistory();
      }, 1000); // 模拟网络延迟
      return;
    }
    
    // 真实API调用
    // 使用局域网IP地址以支持真机调试，localhost在真机上无法访问
    const baseUrl = 'http://192.168.189.238:8899'; // 请根据实际开发机IP地址修改
    
    wx.request({
      url: `${baseUrl}/ai/generate`,
      method: 'GET',
      data: {
        message: question
      },
      success: (res) => {
        console.log('AI接口响应:', res);
        console.log('响应状态码:', res.statusCode);
        console.log('响应数据类型:', typeof res.data);
        console.log('响应数据内容:', res.data);
        
        // 移除加载消息
        const messages = this.data.messages.slice(0, -1);
        
        // 处理响应数据，支持多种格式
        let aiResponse = '';
        if (typeof res.data === 'string') {
          // 如果直接返回字符串
          aiResponse = res.data;
        } else if (res.data && res.data.answer) {
          // 如果返回JSON格式的answer字段
          aiResponse = res.data.answer;
        } else if (res.data && res.data.message) {
          // 如果返回JSON格式的message字段
          aiResponse = res.data.message;
        } else {
          aiResponse = '抱歉，我暂时无法回答这个问题，请稍后再试。';
        }
        
        // 立即开始流式输出，不等待
        this.startStreamingOutput(messages, aiResponse);
      },
      fail: (error) => {
        console.error('AI接口调用失败:', error);
        console.error('错误详情:', error.errMsg);
        
        // 移除加载消息
        const messages = this.data.messages.slice(0, -1);
        
        // 检查是否是域名问题
        if (error.errMsg && error.errMsg.includes('url not in domain list')) {
          // 域名未配置，使用模拟回复
          const mockResponse = this.getMockAIResponse(question);
          const fullResponse = mockResponse + '\n\n⚠️ 当前为开发模式，请确保在微信开发者工具中关闭域名校验';
          
          // 使用流式输出显示模拟回复
          this.startStreamingOutput(messages, fullResponse);
          
          // 显示提示
          wx.showToast({
            title: '域名校验失败，使用模拟回复',
            icon: 'none',
            duration: 3000
          });
        } else {
          // 其他网络错误
          const errorMessage = {
            type: 'ai',
            content: '抱歉，网络连接出现问题，请检查网络后重试。\n\n错误信息：' + (error.errMsg || '未知错误'),
            isLoading: false,
            timestamp: Date.now()
          };
          
          this.setData({
            messages: [...messages, errorMessage],
            isLoading: false
          });
          
          wx.showToast({
            title: '网络错误',
            icon: 'none',
            duration: 2000
          });
        }
        
        // 滚动到底部
        this.scrollToBottom();
      }
    });
  },

  // 滚动到底部
  scrollToBottom: function() {
    const messageCount = this.data.messages.length;
    this.setData({
      scrollToView: `message-${messageCount - 1}`
    });
  },

  // 清空聊天记录
  clearChat: function() {
    wx.showModal({
      title: '确认清空',
      content: '确定要清空所有聊天记录吗？',
      success: (res) => {
        if (res.confirm) {
          this.setData({
            messages: []
          });
          this.addWelcomeMessage();
        }
      }
    });
  },


  // 打开历史记录
  openHistory: function() {
    wx.navigateTo({
      url: '/pages/chat-history/chat-history'
    });
  },

  // 返回上一页
  goBack: function() {
    wx.navigateBack({
      delta: 1
    });
  },

  // 切换流式输出速度
  toggleSpeed: function() {
    const speeds = ['fast', 'normal', 'slow'];
    const currentIndex = speeds.indexOf(this.data.streamSpeed);
    const nextIndex = (currentIndex + 1) % speeds.length;
    const nextSpeed = speeds[nextIndex];
    
    this.setData({
      streamSpeed: nextSpeed
    });
    
    const speedNames = {
      'fast': '快速',
      'normal': '正常', 
      'slow': '慢速'
    };
    
    wx.showToast({
      title: `已切换到${speedNames[nextSpeed]}模式`,
      icon: 'none',
      duration: 1500
    });
  },

  // 切换语音输入
  toggleVoiceInput: function() {
    console.log('切换语音输入，当前录音状态:', this.data.isRecording);
    if (this.data.isRecording) {
      // 正在录音，停止录音
      this.stopVoiceRecording();
    } else {
      // 未在录音，开始录音
      this.startVoiceRecording();
    }
  },

  // 开始语音录制
  startVoiceRecording: function() {
    if (this.data.isRecording) {
      console.log('语音录制已开始');
      return;
    }
    
    console.log('开始语音录制流程...');
    
    // 尝试最基础的录音方法
    this.basicStartRecording();
  },

  // 最基础的录音方法（用于调试）
  basicStartRecording: function() {
    console.log('=== 开始基础录音方法调试 ===');
    
    // 检查是否在开发者工具中运行
    const systemInfo = wx.getSystemInfoSync();
    const isDevTool = systemInfo.platform === 'devtools';
    
    if (isDevTool) {
      console.log('⚠️ 检测到在开发者工具中运行');
      wx.showModal({
        title: '录音功能提示',
        content: '录音功能在开发者工具中可能不稳定，建议在真机上测试。\n\n是否继续尝试？',
        showCancel: true,
        confirmText: '继续',
        cancelText: '取消',
        success: (res) => {
          if (res.confirm) {
            this.attemptRecording();
          }
        }
      });
      return;
    }
    
    this.attemptRecording();
  },
  
  // 尝试录音的核心方法
  attemptRecording: function() {
    try {
      const recorderManager = this.data.voiceRecorder;
      console.log('录音管理器状态:', recorderManager);
      
      if (!recorderManager) {
        console.error('录音管理器未初始化，重新初始化...');
        this.initRecorderManager();
        return;
      }
      
      // 检查录音管理器的方法
      console.log('录音管理器方法检查:', {
        hasStart: typeof recorderManager.start === 'function',
        hasStop: typeof recorderManager.stop === 'function',
        hasOnStart: typeof recorderManager.onStart === 'function',
        hasOnStop: typeof recorderManager.onStop === 'function',
        hasOnError: typeof recorderManager.onError === 'function'
      });
      
      // 最简单的录音配置
      const options = {
        duration: 60000,
        sampleRate: 16000,
        numberOfChannels: 1,
        format: 'mp3'
      };
      
      console.log('录音配置参数:', options);
      console.log('准备调用 recorderManager.start()...');
      
      this.setData({
        isRecording: true
      });
      
      // 设置超时检测，如果3秒内没有收到onStart事件，认为启动失败
      const startTimeout = setTimeout(() => {
        console.error('录音启动超时，可能是开发者工具限制');
        this.setData({
          isRecording: false
        });
        
        wx.showModal({
          title: '录音启动失败',
          content: '录音功能在当前环境下无法正常工作。\n\n建议：\n1. 在真机上测试\n2. 检查录音权限\n3. 使用文字输入替代',
          showCancel: false,
          confirmText: '知道了'
        });
      }, 3000);
      
      // 添加临时的成功回调来检测是否真的开始了
      const originalOnStart = recorderManager.onStart;
      recorderManager.onStart = () => {
        console.log('✅ 录音真正开始了！');
        clearTimeout(startTimeout); // 清除超时检测
        if (originalOnStart) originalOnStart();
      };
      
      recorderManager.start(options);
      console.log('recorderManager.start() 调用完成');
      
      wx.showToast({
        title: '正在启动录音...',
        icon: 'none',
        duration: 1000
      });
      
    } catch (error) {
      console.error('=== 基础录音启动异常 ===');
      console.error('错误详情:', error);
      console.error('错误堆栈:', error.stack);
      
      this.setData({
        isRecording: false
      });
      
      wx.showModal({
        title: '录音功能异常',
        content: `录音启动失败：${error.message}\n\n建议在真机上测试录音功能。`,
        showCancel: false,
        confirmText: '知道了'
      });
    }
  },

  // 设置录音事件监听器（只在初始化时调用一次）
  setupRecorderEvents: function(recorderManager) {
    if (!recorderManager) {
      console.error('录音管理器为空，无法设置事件监听器');
      return;
    }
    
    console.log('=== 开始设置录音事件监听器 ===');
    console.log('录音管理器对象:', recorderManager);
    
    try {
      // 录音开始事件
      recorderManager.onStart(() => {
        console.log('🎤 录音开始事件触发 - 录音真正开始了！');
        this.setData({
          isRecording: true
        });
        
        wx.showToast({
          title: '正在录音...',
          icon: 'none',
          duration: 1000
        });
      });
      
      // 录音结束事件
      recorderManager.onStop((res) => {
        console.log('🛑 录音结束事件触发');
        console.log('录音结果详情:', res);
        console.log('录音文件大小:', res.fileSize);
        console.log('录音时长:', res.duration);
        console.log('录音格式:', res.format);
        
        this.setData({
          isRecording: false
        });
        
        if (res.tempFilePath) {
          console.log('✅ 录音文件路径:', res.tempFilePath);
          // 上传音频进行语音识别
          this.uploadAudioForRecognition(res.tempFilePath);
        } else {
          console.error('❌ 录音文件路径为空');
          wx.showToast({
            title: '录音文件获取失败',
            icon: 'none',
            duration: 2000
          });
        }
      });
      
      // 录音错误事件
      recorderManager.onError((res) => {
        console.error('❌ 录音错误事件触发');
        console.error('错误详情:', res);
        console.error('错误代码:', res.errCode);
        console.error('错误消息:', res.errMsg);
        
        this.setData({
          isRecording: false
        });
        
        let errorMsg = '录音失败';
        if (res.errMsg) {
          errorMsg = res.errMsg;
          // 特殊处理常见错误
          if (res.errMsg.includes('Failed to fetch')) {
            errorMsg = '录音服务连接失败，请检查网络或在真机上测试';
          } else if (res.errMsg.includes('permission')) {
            errorMsg = '录音权限被拒绝，请允许录音权限';
          }
        }
        
        wx.showToast({
          title: errorMsg,
          icon: 'none',
          duration: 3000
        });
      });
      
      console.log('✅ 录音事件监听器设置完成');
      
    } catch (error) {
      console.error('❌ 设置录音事件监听器失败:', error);
      wx.showToast({
        title: '录音事件设置失败',
        icon: 'none',
        duration: 2000
      });
    }
  },

  // 停止语音录制
  stopVoiceRecording: function() {
    console.log('停止录音...');
    
    if (!this.data.voiceRecorder) {
      console.error('录音管理器未初始化');
      return;
    }
    
    if (!this.data.isRecording) {
      console.log('当前没有在录音');
      return;
    }
    
    try {
      this.data.voiceRecorder.stop();
      console.log('录音已停止');
      
      wx.showToast({
        title: '正在识别...',
        icon: 'loading',
        duration: 3000
      });
    } catch (error) {
      console.error('停止录音失败:', error);
      this.setData({
        isRecording: false
      });
    }
  },



  // 开始流式输出
  startStreamingOutput: function(messages, fullText) {
    // 立即添加AI消息到消息列表，开始显示内容
    const aiMessage = {
      type: 'ai',
      content: '',
      isLoading: false,
      isStreaming: true,
      timestamp: Date.now()
    };
    
    const newMessages = [...messages, aiMessage];
    this.setData({
      messages: newMessages,
      isLoading: false,
      isStreaming: true,
      streamingText: fullText,
      streamingIndex: 0
    });
    
    // 立即开始逐字显示，不延迟
    setTimeout(() => {
      this.streamText();
    }, 10); // 很短的延迟确保界面更新
  },

  // 流式显示文本
  streamText: function() {
    if (!this.data.isStreaming) return;
    
    const { streamingText, streamingIndex } = this.data;
    
    if (streamingIndex >= streamingText.length) {
      // 流式输出完成
      this.setData({
        isStreaming: false,
        streamingText: '',
        streamingIndex: 0
      });
      this.scrollToBottom();
      
      // 保存对话记录
      this.saveChatHistory();
      return;
    }
    
    // 计算本次要显示的文字数量（可以调整速度）
    const charsPerStep = this.getCharsPerStep(streamingText, streamingIndex);
    const newIndex = Math.min(streamingIndex + charsPerStep, streamingText.length);
    const currentText = streamingText.substring(0, newIndex);
    
    // 更新消息内容
    const messages = [...this.data.messages];
    const lastMessage = messages[messages.length - 1];
    if (lastMessage && lastMessage.type === 'ai') {
      lastMessage.content = currentText;
      lastMessage.isStreaming = newIndex < streamingText.length;
    }
    
    this.setData({
      messages: messages,
      streamingIndex: newIndex
    });
    
    // 滚动到底部
    this.scrollToBottom();
    
    // 继续下一轮
    setTimeout(() => {
      this.streamText();
    }, this.getStreamDelay());
  },

  // 获取每次显示的字数（根据标点符号调整）
  getCharsPerStep: function(text, currentIndex) {
    const char = text[currentIndex];
    
    // 遇到标点符号时停顿更久
    if (['。', '！', '？', '；', '\n'].includes(char)) {
      return 1;
    }
    // 遇到逗号时稍微停顿
    else if (['，', '、'].includes(char)) {
      return 1;
    }
    // 普通字符 - 可以一次显示多个字符提升速度
    else {
      return 1; // 保持逐字显示，但通过减少延迟来提升速度
    }
  },

  // 获取流式输出的延迟时间
  getStreamDelay: function() {
    const { streamingText, streamingIndex, streamSpeed } = this.data;
    const char = streamingText[streamingIndex];
    
    // 根据速度设置基础延迟（大幅提升速度）
    let baseDelay = 30;
    switch(streamSpeed) {
      case 'fast':
        baseDelay = 10; // 超快速度
        break;
      case 'normal':
        baseDelay = 30; // 正常速度
        break;
      case 'slow':
        baseDelay = 60; // 慢速
        break;
    }
    
    // 根据字符类型调整延迟（减少停顿时间）
    if (['。', '！', '？', '；', '\n'].includes(char)) {
      return baseDelay * 2; // 句号等停顿时间减半
    } else if (['，', '、'].includes(char)) {
      return baseDelay * 1.5; // 逗号等停顿时间减少
    } else {
      return baseDelay; // 普通字符
    }
  },

  // 获取模拟AI回复
  getMockAIResponse: function(question) {
    // 根据问题内容返回不同的智能回复
    if (question.includes('数学') || question.includes('计算') || question.includes('算')) {
      const mathResponses = [
        '这是一个数学问题！让我来帮你分析一下解题思路。首先我们需要理解题目的条件，然后选择合适的公式和方法。',
        '数学学习要注重理解概念！对于这道题，我建议你先分析已知条件，然后确定解题步骤。',
        '计算题需要仔细！让我来帮你检查每一步的计算过程，确保答案正确。',
        '这是一个很好的数学问题！我们可以用多种方法来解，你想了解哪种方法呢？'
      ];
      return mathResponses[Math.floor(Math.random() * mathResponses.length)];
    } 
    else if (question.includes('语文') || question.includes('作文') || question.includes('阅读')) {
      const chineseResponses = [
        '语文学习需要多读多练！对于这个问题，我建议你先理解文章的主旨，然后分析具体的语言表达技巧。',
        '作文写作要注重结构和语言！让我来帮你分析一下如何组织思路和表达观点。',
        '阅读理解需要仔细分析！我们可以从文章的结构、语言特色和主题思想入手。',
        '这是一个很好的语文问题！让我来帮你分析一下文章的表达技巧和深层含义。'
      ];
      return chineseResponses[Math.floor(Math.random() * chineseResponses.length)];
    } 
    else if (question.includes('英语') || question.includes('English')) {
      const englishResponses = [
        '英语学习要注重听说读写全面！对于你提到的问题，我建议多听多练，培养语感。',
        '语法学习需要多练习！让我来帮你分析一下这个语法点的用法和注意事项。',
        '英语写作要注重逻辑和表达！我们可以从词汇选择、句式结构和段落组织入手。',
        '这是一个很好的英语问题！让我来帮你提高英语表达能力。'
      ];
      return englishResponses[Math.floor(Math.random() * englishResponses.length)];
    }
    else if (question.includes('物理') || question.includes('化学') || question.includes('生物')) {
      const scienceResponses = [
        '理科学习要注重实验和理论结合！对于这个问题，我建议你先理解基本概念，然后分析实验现象。',
        '科学问题需要严谨的思维！让我来帮你分析一下这个现象背后的科学原理。',
        '实验题要注重观察和推理！我们可以从实验现象入手，分析可能的原因。',
        '这是一个很好的科学问题！让我来帮你理解相关的科学概念。'
      ];
      return scienceResponses[Math.floor(Math.random() * scienceResponses.length)];
    }
    else if (question.includes('你好') || question.includes('hello') || question.includes('hi')) {
      const greetingResponses = [
        '你好！高兴为你服务！有什么学习问题需要帮助吗？',
        '你好！我是你的学习助手，随时准备为你解答问题！',
        '你好！欢迎使用AI解题助手！我会尽力帮助你解决学习中的难题。',
        '你好！有什么问题尽管问我，我会认真为你解答！'
      ];
      return greetingResponses[Math.floor(Math.random() * greetingResponses.length)];
    }
    else {
      const generalResponses = [
        '这是一个很好的问题！让我来帮你分析一下解题思路。',
        '根据你的问题，我建议从以下几个方面来思考。',
        '这个问题涉及到多个知识点，我们需要逐步分析。',
        '让我用简单易懂的方式来解释这个概念。',
        '这是一个常见的问题，很多同学都会遇到。',
        '要解决这个问题，我们需要先理解基本概念。',
        '让我为你详细解答这个问题。',
        '这个问题很有趣，让我来为你分析一下。'
      ];
      return generalResponses[Math.floor(Math.random() * generalResponses.length)];
    }
  },

  // 上传音频进行语音识别（百度云）
  uploadAudioForRecognition: async function(audioFilePath) {
    wx.showLoading({
      title: '识别中...',
      mask: true
    });

    try {
      // 调用后端语音识别API
      // 使用局域网IP地址以支持真机调试，localhost在真机上无法访问
      wx.uploadFile({
        url: 'http://192.168.189.238:9988/voice/recognize', // 请根据实际开发机IP地址修改
        filePath: audioFilePath,
        name: 'audio',
        timeout: 30000, // 设置30秒超时
        formData: {
          'format': 'mp3',
          'sampleRate': '16000'
        },
        success: (res) => {
          wx.hideLoading();
          console.log('后端语音识别结果:', res.data);
          
          try {
            const result = JSON.parse(res.data);
            
            if (result.success && result.text) {
              // 识别成功，更新输入框
              this.setData({
                inputText: result.text
              });
              
              wx.showToast({
                title: '识别成功',
                icon: 'success',
                duration: 1500
              });
              
              // 自动发送消息
              setTimeout(() => {
                this.sendMessage();
              }, 1000);
            } else {
              wx.showToast({
                title: result.message || '识别失败',
                icon: 'none',
                duration: 2000
              });
            }
          } catch (parseError) {
            console.error('解析识别结果失败:', parseError);
            wx.showToast({
              title: '识别结果解析失败',
              icon: 'none',
              duration: 2000
            });
          }
        },
        fail: (error) => {
          wx.hideLoading();
          console.error('语音识别请求失败:', error);
          
          let errorMsg = '识别失败';
          if (error.errMsg && error.errMsg.includes('network')) {
            errorMsg = '网络连接失败，请检查网络';
          } else if (error.errMsg && error.errMsg.includes('timeout')) {
            errorMsg = '请求超时，请重试';
          }
          
          wx.showToast({
            title: errorMsg,
            icon: 'none',
            duration: 2000
          });
        }
      });
    } catch (error) {
      wx.hideLoading();
      console.error('语音识别异常:', error);
      
      wx.showToast({
        title: '语音识别异常',
        icon: 'none',
        duration: 2000
      });
    }
  },

  // 创建新对话
  createNewChat: function() {
    const chatId = 'chat_' + Date.now();
    this.setData({
      chatId: chatId,
      chatTitle: '新对话'
    });
    console.log('创建新对话:', chatId);
  },

  // 加载对话历史
  loadChatHistory: function(chatId) {
    try {
      const history = wx.getStorageSync('chatHistory') || [];
      const chat = history.find(item => item.id === chatId);
      
      if (chat) {
        this.setData({
          messages: chat.messages || [],
          chatTitle: chat.title
        });
        console.log('加载对话历史成功:', chatId);
        // 滚动到底部显示最新消息
        setTimeout(() => {
          this.scrollToBottom();
        }, 100);
      } else {
        console.log('未找到对话历史:', chatId);
        this.createNewChat();
      }
    } catch (error) {
      console.error('加载对话历史失败:', error);
      this.createNewChat();
    }
  },

  // 保存对话记录
  saveChatHistory: function() {
    if (!this.data.chatId || this.data.messages.length <= 1) {
      return; // 没有对话ID或消息太少时不保存
    }

    try {
      const history = wx.getStorageSync('chatHistory') || [];
      const chatIndex = history.findIndex(item => item.id === this.data.chatId);
      
      // 生成对话标题（取第一条用户消息的前20个字符）
      const firstUserMessage = this.data.messages.find(msg => msg.type === 'user');
      const title = firstUserMessage ? 
        (firstUserMessage.content.length > 20 ? 
          firstUserMessage.content.substring(0, 20) + '...' : 
          firstUserMessage.content) : 
        'AI对话';
      
      // 生成预览文本（取最后一条AI消息的前50个字符）
      const lastAiMessage = [...this.data.messages].reverse().find(msg => msg.type === 'ai');
      const preview = lastAiMessage ? 
        (lastAiMessage.content.length > 50 ? 
          lastAiMessage.content.substring(0, 50) + '...' : 
          lastAiMessage.content) : 
        '暂无内容';
      
      const chatData = {
        id: this.data.chatId,
        title: title,
        preview: preview,
        messages: this.data.messages,
        messageCount: this.data.messages.length,
        timestamp: new Date().toISOString(),
        time: this.formatTime(new Date()),
        date: this.formatDate(new Date())
      };
      
      if (chatIndex >= 0) {
        // 更新现有对话
        history[chatIndex] = chatData;
      } else {
        // 添加新对话
        history.unshift(chatData);
      }
      
      // 限制历史记录数量（最多保存50个对话）
      if (history.length > 50) {
        history.splice(50);
      }
      
      wx.setStorageSync('chatHistory', history);
      console.log('保存对话记录成功:', this.data.chatId);
      
    } catch (error) {
      console.error('保存对话记录失败:', error);
    }
  },

  // 格式化时间
  formatTime: function(date) {
    const now = new Date();
    const diff = now - date;
    const minutes = Math.floor(diff / 60000);
    const hours = Math.floor(diff / 3600000);
    const days = Math.floor(diff / 86400000);
    
    if (minutes < 1) return '刚刚';
    if (minutes < 60) return `${minutes}分钟前`;
    if (hours < 24) return `${hours}小时前`;
    if (days < 7) return `${days}天前`;
    
    return date.toLocaleDateString('zh-CN', {
      month: 'short',
      day: 'numeric'
    });
  },

  // 格式化日期
  formatDate: function(date) {
    return date.toLocaleDateString('zh-CN', {
      year: 'numeric',
      month: 'long',
      day: 'numeric'
    });
  },

  // 录音按钮点击事件
  onVoiceButtonTap: function() {
    console.log('录音按钮被点击，当前录音状态:', this.data.isRecording);
    
    if (this.data.isRecording) {
      // 如果正在录音，停止录音
      this.stopVoiceRecording();
    } else {
      // 如果没有录音，开始录音 - 使用基础录音方法
      this.basicStartRecording();
    }
  }
});
